Continuous Collision Detection Algorithm Research Articles

Deep Neural Network-Based Cloth Collision Detection Algorithm

The quality of collision detection algorithm directly affects the performance of the whole simulation system. To address the low efficiency and low accuracy in detecting the collisions of flexible cloths in virtual environments, this paper proposes an oriented bounding box (OBB) algorithm with a simplified model, tree structure for a root-node double bounding box, and continuous collision detection algorithm incorporating an OpenNN-based neural network optimization. First, for objects interacting with the cloths with more complex modeling, the model is simplified with a surface simplification algorithm based on the quadric error metrics, and the simplified model is used to construct an OBB. Second, a bounding box technique commonly used for collision detection is improved, and a root-node double bounding box algorithm is proposed to reduce the construction time for the bounding box. Finally, neural networks are used to optimize the continuous collision detection algorithm, as neural networks can efficiently process large amounts of data and remove disjoint collision pairs. An experiment shows that the construction of an OBB using the simplified model is almost identical to that of the original model, but the taken to construct the OBB is reduced by a factor of approximately 2.7. For the same cloth, it takes 5.51%–11.32% less time to run the root-node double bounding box algorithm than the traditional-hybrid bounding box algorithm. With an average removal rate nearly identical to that of the traditional filtering method, the elapsed time is reduced by 7%–11% by using the continuous collision detection algorithm based on an OpenNN neural network optimization. The simulation results are realistic and in line with the requirements for real-time cloth simulations.

A Large-scale Benchmark and an Inclusion-based Algorithm for Continuous Collision Detection

We introduce a large-scale benchmark for continuous collision detection (CCD) algorithms, composed of queries manually constructed to highlight challenging degenerate cases and automatically generated using existing simulators to cover common cases. We use the benchmark to evaluate the accuracy, correctness, and efficiency of state-of-the-art continuous collision detection algorithms, both with and without minimal separation. We discover that, despite the widespread use of CCD algorithms, existing algorithms are (1) correct but impractically slow; (2) efficient but incorrect, introducing false negatives that will lead to interpenetration; or (3) correct but over conservative, reporting a large number of false positives that might lead to inaccuracies when integrated in a simulator. By combining the seminal interval root finding algorithm introduced by Snyder in 1992 with modern predicate design techniques, we propose a simple and efficient CCD algorithm. This algorithm is competitive with state-of-the-art methods in terms of runtime while conservatively reporting the time of impact and allowing explicit tradeoff between runtime efficiency and number of false positives reported.

Medial IPC

We propose a framework of efficient nonlinear deformable simulation with both fast continuous collision detection and robust collision resolution. We name this new framework Medial IPC as it integrates the merits from medial elastics, for an efficient and versatile reduced simulation, as well as incremental potential contact, for a robust collision and contact resolution. We leverage medial axis transform to construct a kinematic subspace. Instead of resorting to projective dynamics, we use classic hyperelastics to embrace real-world nonlinear materials. A novel reduced continuous collision detection algorithm is presented based on the medial mesh. Thanks to unique geometric properties of medial axis and medial primitives, we derive closed-form formulations for identifying between-primitive collision within the reduced medial space. In the meantime, the implicit barrier energy that generates necessary repulsion forces for collision resolution is also formulated with the medial coordinate. In other words, Medial IPC exploits a universal reduced coordinate for simulation, continuous self-/collision detection, and IPC-based collision resolution. Continuous collision detection also allows more aggressive time stepping. In addition, we carefully implement our system with a heterogeneous CPU-GPU deployment such that massively parallelizable computations are carried out on the GPU while few sequential computations are on the CPU. Such implementation also frees us from generating training poses for selecting Cubature points and pre-computing their weights. We have tested our method on complicated deformable models and collision-rich simulation scenarios. Due to the reduced nature of our system, the computation is faster than fullspace IPC or other fullspace methods using continuous collision detection by at least one order. The simulation remains high-quality as the medial subspace captures intriguing and local deformations with sufficient realism.

An enhanced sweep and prune algorithm for multi-body continuous collision detection

Multi-body collision detection is a key and important technology in societies of computer graphics, system simulation, virtual reality, etc. and has been widely used in various graphics applications. To deal with the collision detection problem in large-scale multi-body scenes, we in this paper proposed a robust and efficient algorithm based on the kinetic “sweep and prune” technique and the event-driven mechanism. Our algorithm first culls redundant detection calculations in finding object pairs that do not collide in the scene with very large number of moving objects and then automatically generates events to predict the object collisions, which probably take place in near future. All the events are pushed into an optimized priority queue to drive the proposed algorithm. By introducing a hybrid bounding box hierarchy in the event processing process, the algorithm can detect the positions where the object pairs collide. Based on our finding that event blocking is an important factor affecting the robustness of the algorithm, we further propose several techniques to alarm blockings to be occurred or relieve the system from blocking state. Experimental results show that our algorithm has good stability and robustness, and it can improve the operating efficiency of multi-body continuous collision detections in an efficient way.

I-cloth

We present an incremental collision handling algorithm for GPU-based interactive cloth simulation. Our approach exploits the spatial and temporal coherence between successive iterations of an optimization-based solver for collision response computation. We present an incremental continuous collision detection algorithm that keeps track of deforming vertices and combine it with spatial hashing. We use a non-linear GPU-based impact zone solver to resolve the penetrations. We combine our collision handling algorithm with implicit integration to use large time steps. Our overall algorithm, I-Cloth, can simulate complex cloth deformation with a few hundred thousand vertices at 2 - 8 frames per second on a commodity GPU. We highlight its performance on different benchmarks and observe up to 7 - 10X speedup over prior algorithms.

Efficient and Reliable Self‐Collision Culling Using Unprojected Normal Cones

AbstractWe present an efficient and accurate algorithm for self‐collision detection in deformable models. Our approach can perform discrete and continuous collision queries on triangulated meshes. We present a simple and linear time algorithm to perform the normal cone test using the unprojected 3D vertices, which reduces to a sequence point‐plane classification tests. Moreover, we present a hierarchical traversal scheme that can significantly reduce the number of normal cone tests and the memory overhead using front‐based normal cone culling. The overall algorithm can reliably detect all (self) collisions in models composed of hundreds of thousands of triangles. We observe considerable performance improvement over prior continuous collision detection algorithms.

DCCD: Distributed N-Body Rigid Continuous Collision Detection for Large-Scale Virtual Environments

Continuous collision detection (CCD) is a process to interpolate the trajectory of polygons and detect collisions between successive time steps. However, this process is time-consuming, especially for a large number of moving polygons. In this paper, we present a parallel CCD algorithm, which aims to accelerate N-body rigid CCD culling by distributing the load across a distributed-memory system. This algorithm is particularly suitable for large-scale distributed simulations. Experimental results, based on a message passing interface implementation, demonstrate that our approach is more computationally efficient than existing sequential CCD approaches.

6-DoF Haptic Rendering Using Continuous Collision Detection between Points and Signed Distance Fields.

We present an algorithm for fast continuous collision detection between points and signed distance fields, and demonstrate how to robustly use it for 6-DoF haptic rendering of contact between objects with complex geometry. Continuous collision detection is often needed in computer animation, haptics, and virtual reality applications, but has so far only been investigated for polygon (triangular) geometry representations. We demonstrate how to robustly and continuously detect intersections between points and level sets of the signed distance field. We suggest using an octree subdivision of the distance field for fast traversal of distance field cells. We also give a method to resolve continuous collisions between point clouds organized into a tree hierarchy and a signed distance field, enabling rendering of contact between rigid objects with complex geometry. We investigate and compare two 6-DoF haptic rendering methods now applicable to point-versus-distance field contact for the first time: continuous integration of penalty forces, and a constraint-based method. An experimental comparison to discrete collision detection demonstrates that the continuous method is more robust and can correctly resolve collisions even under high velocities and during complex contact.

A fast algebraic non-penetration filter for continuous collision detection

Continuous collision detection is a key technique to meet non-penetration requirements in many applications. Even though it is possible to perform efficient culling operations in the broad stage of a continuous collision detection algorithm, such as bounding volume hierarchies, a huge number of potentially colliding triangles still survive and go to the succeeding narrow stage. This heavily burdens the elementary collision tests in a collision detection algorithm and affects the performance of the entire pipeline, especially for fast moving or deforming objects. This paper presents a low-cost filtering algorithm using algebraic analysis techniques. It can significantly reduce the number of elementary collision tests that occur in the narrow stage. We analyze the root existence during the time interval [0, 1] for a standard cubic equation defining an elementary collision test. We demonstrate the efficiency of the algebraic filter in our experiments. Cubic-solvers augmented by our filtering algorithm are able to achieve up to 99% filtering ratios and more than 10 × performance improvement against the standard cubic-solver without any filters.

Interactive Continuous Collision Detection for Topology Changing Models Using Dynamic Clustering.

We present a fast algorithm for continuous collision detection between deformable models. Our approach performs no precomputation and can handle general triangulated models undergoing topological changes. We present a fast decomposition algorithm that represents the mesh boundary using hierarchical clusters and only needs to perform inter-cluster collision checks. The key idea is to compute such clusters quickly and merge them to generate a dynamic bounding volume hierarchy. The overall approach reduces the overhead of computing the hierarchy and also reduces the number of false positives. We highlight the the algorithm's performance on many complex benchmarks generated from medical simulations and crash analysis. In practice, we observe 1.4 to 5 times speedup over prior CCD algorithms for deformable models in our benchmarks.

Minimum Normal Cone for Continuous Collision Detection

Continuous collision detection (CCD) algorithm is a vital step in virtual reality. This paper describes an efficient self-collision detection algorithm called the minimum normal cone algorithm. The algorithm calculates the parent-normal cone in a new way, which optimizes the two test conditions for the self-collision detection: In the first test condition, we analyze and calculate the relative position between the two child-normal cones, and then a bottom-up technology is used to build the parent-normal cone. Thus the two child normal cones can be surrounded by the parent-normal cone perfectly, and the normal vectors motion range of the parent-triangular mesh can also be closely restricted; In the second test condition, we calculate the normal vectors motion range of the contour projection line, and check whether the projection line is self-colliding or not, to avoid excessive tests between segments. The algorithm has been implemented and tested on two classical models, cloth-ball and N-body model respectively. Experimental results demonstrate that our algorithm can decrease the number of elementary tests by two orders of magnitudes, and significantly improve the performance of the overall CCD algorithm.

Collision Detection between Rigid Bodies Based on Adaptive Test Lines

A novel algorithm, which can check the collision point of rigid objects continuously and solve the problem of penetration and crossing in collision detection effectively, is presented in this paper. At each simulation moment, the adaptive test lines (ATLs) are first constructed based on the velocity vector of the moving object and then the intersection between the ATLs and the environment is calculated. The collision happens when the intersection is not empty and the collision point is obtained through crossing-frame processing. By checking the interference between body and ATLs instead of bodies, we greatly improve the detection efficiency. It avoids missing collisions for an object with arbitrary shape or in any motion states. Simulation results show that our algorithm runs faster than the general continuous collision detection algorithms and has similar detection effects to the swept volume algorithm.

Fast continuous collision culling with deforming noncollinear filters

ABSTRACTWe present a novel culling algorithm that uses deforming noncollinear filters to improve the performance of continuous collision detection (CCD) algorithms. The underlying idea is to use simple and effective filters, deforming noncollinear filters (NCFs), that reduce the number of false positives between the primitives. These filters are derived from the collinear conditions and can be easily combined with other culling methods. We have tested its performance on several benchmarks. Comparing with previous methods, we can reduce the number of false positives significantly and improve the overall performance of CCD algorithms, especially for simulations with large time steps. Copyright © 2012 John Wiley & Sons, Ltd.

PolyDepth

We present a real-time algorithm that finds the Penetration Depth (PD) between general polygonal models based on iterative and local optimization techniques. Given an in-collision configuration of an object in configuration space, we find an initial collision-free configuration using several methods such as centroid difference, maximally clear configuration, motion coherence, random configuration, and sampling-based search. We project this configuration on to a local contact space using a variant of continuous collision detection algorithm and construct a linear convex cone around the projected configuration. We then formulate a new projection of the in-collision configuration onto the convex cone as a Linear Complementarity Problem (LCP), which we solve using a type of Gauss-Seidel iterative algorithm. We repeat this procedure until a locally optimal PD is obtained. Our algorithm can process complicated models consisting of tens of thousands triangles at interactive rates.

Graphics Hardware Accelerated Continuous Collision Detection Between Deformable Objects

This paper presents a graphics hardware accelerated continuous collision detection algorithm for deformable objects.It can detect all inter-object and intra-object collisions for complex scenes which consist of deformable objects in real time.The algorithm executes collision detection tasks fully in parallel by mapping them with streaming decomposition.With parallel streaming registration algorithm,variable length data structures are efficiently supported on graphics hardware.The algorithm has been implemented on AMD graphics hardware platform with OpenCL.A serial of benchmarks with different characteristics are used for testing.Comparing to an optimized single-threaded CPU implementation on Intel Q6600@2.4 GHz,the algorithm achieves 9.2x~11.4x speedups.

MCCD: Multi-core collision detection between deformable models using front-based decomposition

We present a novel parallel algorithm for fast continuous collision detection (CCD) between deformable models using multi-core processors. We use a hierarchical representation to accelerate these queries and present an incremental algorithm that exploits temporal coherence between successive frames. Our formulation distributes the computation among multiple cores by using fine-grained front-based decomposition. We also present efficient techniques to reduce the number of elementary tests and analyze the scalability of our approach. We have implemented the parallel algorithm on eight core and 16 core PCs, and observe up to 7× and 13× speedups respectively, on complex benchmarks.

ICCD: Interactive Continuous Collision Detection between Deformable Models Using Connectivity-Based Culling

We present an interactive algorithm for continuous collision detection between deformable models. We introduce multiple techniques to improve the culling efficiency and the overall performance of continuous collision detection. First, we present a novel formulation for continuous normal cones and use these normal cones to efficiently cull large regions of the mesh as part of self-collision tests. Second, we introduce the concept of "procedural representative triangles" to remove all redundant elementary tests between nonadjacent triangles. Finally, we exploit the mesh connectivity and introduce the concept of "orphan sets" to eliminate redundant elementary tests between adjacent triangle primitives. In practice, we can reduce the number of elementary tests by two orders of magnitude. These culling techniques have been combined with bounding volume hierarchies and can result in one order of magnitude performance improvement as compared to prior collision detection algorithms for deformable models. We highlight the performance of our algorithm on several benchmarks, including cloth simulations, N-body simulations, and breaking objects.

Continuous Collision Detection for Ellipsoids

We present an accurate and efficient algorithm for continuous collision detection between two moving ellipsoids under rational Euclidean or affine motion. We start with a highly optimized implementation of interference testing between two stationary ellipsoids based on an algebraic condition described in terms of the signs of roots of the characteristic equation of two ellipsoids. Then we derive a time-dependent characteristic equation for two moving ellipsoids, which enables us to develop an efficient algorithm for computing the time intervals in which two moving ellipsoids collide. The effectiveness of our approach is demonstrated with several practical examples.

Continuous collision detection for adaptive simulation of articulated bodies

We perform continuous collision detection (CCD) for articulated bodies where motion is governed by an adaptive dynamics simulation. Our algorithm is based on a novel hierarchical set of transforms that represent the kinematics of an articulated body recursively, as described by an assembly tree. The performance of our CCD algorithm significantly improves as the number of active degrees of freedom in the simulation decreases.

Continuous collision detection for articulated models using Taylor models and temporal culling

We present a fast continuous collision detection (CCD) algorithm for articulated models using Taylor models and temporal culling. Our algorithm is a generalization of conservative advancement (CA) from convex models [Mirtich 1996] to articulated models with non-convex links. Given the initial and final configurations of a moving articulated model, our algorithm creates a continuous motion with constant translational and rotational velocities for each link, and checks for interferences between the articulated model under continuous motion and other models in the environment and for self-collisions. If collisions occur, our algorithm reports the first time of contact (TOC) as well as collision witness features . We have implemented our CCD algorithm and applied it to several challenging scenarios including locomotion generation, articulated-body dynamics and character motion planning. Our algorithm can perform CCDs including self-collision detection for articulated models consisting of many links and tens of thousands of triangles in 1.22 ms on average running on a 3.6 GHz Pentium 4 PC. This is an improvement on the performance of prior algorithms of more than an order of magnitude.